package token;

public class Token
{

	public enum TokenType 
	{

		//EXPRESSIONS

		MULTIPLICATION_OPERATOR,DIVISION_OPERATOR,

		//VARIABLE AND IDENTIFIER CATEGORIES
		IDENTIFIER,FIELD_IDENTIFIER,CONSTANT_IDENTIFIER,VARIABLE_IDENTIFIER,TYPE_IDENTIFIER,PROCEDURE_IDENTIFIER,
		FUNCTION_IDENTIFIER,BOUND_IDENTIFIER,

		//LOW LEVEL DEFINITIONS
		SIGN,UNSIGNED_DIGIT_SEQUENCE,DIGIT_SEQUENCE,INTEGER_NUMBER,SCALE_FACTOR,REAL_NUMBER,NUMBER,STRING,IDENTIFIER_LIST,

		//RESERVED WORDS
		ABSOLUTE, ABSTRACT,ALIAS,AND,ARRAY,AS,ASM,ASSEMBLER,BEGIN,BREAK,CASE,CDECL,CLASS,CONST,CONSTRUCTOR,CONTINUE,DEFAULT,
		DESTRUCTOR,DISPOSE,DIV,DO,DOWNTO,ELSE,END,EXCEPT,EXIT,EXPORT,EXPORTS,EXTERNAL,FALSE,FAR,FILE,FINALIZATION,FINALLY,
		FOR,FORWARD,FUNCTION,GOTO,IF,IMPLEMENTATION,IN,INDEX,INHERITED,INITIALIZATION,INLINE,INTERFACE,IS,LABEL,LIBRARY,MOD,
		NAME,NEAR,NEW,NIL,NOT,OBJECT,OF,ON, OPERATOR,OR,OVERRIDE,PACKED,PASCAL,POPSTACK,PRIVATE,PROCEDURE,PROGRAM,PROPERTY,
		PROTECTED,PUBLIC,PUBLISHED,RAISE,READ,RECORD,REGISTER,REPEAT,SAVEREGISTERS,SELF,SET,SHL,SHR,STDCALL,THEN,TO,TRUE,TRY,
		TYPE,UNIT,UNTIL,USES,VAR,VIRTUAL,WHILE,WITH,XOR,

		//ADDED
		EOF,O_PAREN,C_PAREN,O_SQBRACKET,C_SQBRACKET,O_CURBRACKET,C_CURBRACKET,SEMICOLON,COLON,COLON_EQUALS,PLUS_SIGN,MINUS_SIGN,COMMA,DOT,
		EQUALS_SIGN,LESS_THAN,GREATER_THAN,LESSEQUALS_THAN,GREATEREQUALS_THAN,DISTINCT,POINTER_TYPE,DOUBLE_DOT,FILE_VARIABLE,RECORD_VARIABLE,
		POINTER_VARIABLE,ACTUAL_VARIABLE,ARRAY_VARIABLE,TYPE_VARIABLE;

		/*NOTE:
		 * PLUS_SIGN and MINUS_SIGN are intended to make capable the substitution of this for SIGN or ADDITION_OPERATOR
		 */
	
		@Override
		public String toString() 
		{
			switch (this) 
			{
			case LESS_THAN:
				return "Relational Operator Less Than \'<\'";
			case GREATER_THAN:
				return "Relational Operator Greater Than \'>\'";
			case LESSEQUALS_THAN:
				return "Relational Operator Less or Equal Than \'<=\'";
			case GREATEREQUALS_THAN:
				return "Relational Operator Greater or Equal Than \'>=\'";
			case DISTINCT:
				return "Relational Operator Distinct \'<>\'";
			case TYPE_VARIABLE:
				return "Type Variable";
			case COLON_EQUALS:
				return "Assign Operator";
			case DIVISION_OPERATOR:
				return "Division Operator";
			case ARRAY_VARIABLE:
				return "Array Variable";
			case ACTUAL_VARIABLE:
				return "Actual Variable";
			case POINTER_VARIABLE:
				return "Pointer Variable";
			case RECORD_VARIABLE:
				return "Record Variable";
			case FILE_VARIABLE:
				return "File Variable";
			case DOUBLE_DOT:
				return "Double dot";
			case POINTER_TYPE:
				return "Pointer Type";
			case COLON:
				return "Colon";
			case EQUALS_SIGN:
				return "Equals sign";
			case DOT:
				return "Dot";
				
			case COMMA:
				return "Comma";
			
			case EOF:
				return "End Of File";

			case O_PAREN:
				return "Open Parenthesis";

			case C_PAREN:
				return "Close Parenthesis";

			case O_CURBRACKET:
				return "Open Curly Bracket";

			case C_CURBRACKET:
				return "Close Curly Bracket";

			case O_SQBRACKET:
				return "Open Square Bracket";

			case C_SQBRACKET:
				return "Close Square Bracket";

			case STRING:
				return "String";

			case IDENTIFIER:
				return "Identifier";

			case SIGN:
				return "Sign";

			case MULTIPLICATION_OPERATOR:
				return "Multiplication Operator";

			case FIELD_IDENTIFIER: 	
				return "Field Identifier";

			case CONSTANT_IDENTIFIER:
				return "Constant Identifier";

			case VARIABLE_IDENTIFIER:
				return "Variable Identifier";

			case TYPE_IDENTIFIER:
				return "Type Identifier";

			case PROCEDURE_IDENTIFIER:
				return "Procedure Identifier";

			case FUNCTION_IDENTIFIER:
				return "Function Identifier";

			case BOUND_IDENTIFIER:
				return "Bound Identifier";

			case UNSIGNED_DIGIT_SEQUENCE:
				return "Unsigned Digit Sequence";

			case DIGIT_SEQUENCE:
				return "Digit Sequence";

			case INTEGER_NUMBER:
				return "Integer Number";

			case SCALE_FACTOR:
				return "Scale Factor";

			case REAL_NUMBER:
				return "Real Number";

			case NUMBER:
				return "Number";

			case IDENTIFIER_LIST:
				return "Identifier List";

			case ABSOLUTE:
				return "Absolute";

			case ABSTRACT:
				return "Abstract";

			case ALIAS:
				return "Alias";

			case AND:
				return "And";

			case ARRAY:
				return "Array";

			case AS:
				return "As";

			case ASM:
				return "Asm";

			case ASSEMBLER:
				return "Assembler";

			case BEGIN:
				return "Begin";

			case BREAK:
				return "Break";

			case CASE:
				return "Case";

			case CDECL:
				return "CDECL";

			case CLASS:
				return "Class";

			case CONST:
				return "Const";

			case CONSTRUCTOR:
				return "Constructor";

			case CONTINUE:
				return "Continue";

			case DEFAULT:
				return "Default";

			case DESTRUCTOR:
				return "Destructor";

			case DISPOSE:
				return "Dispose";

			case DIV:
				return "Div";

			case DO:
				return "Do";

			case DOWNTO:
				return "Down To";

			case ELSE:
				return "Else";

			case END:
				return "End";

			case EXCEPT:
				return "Except";

			case EXIT:
				return "Exit";

			case EXPORTS:
				return "Exports";

			case EXPORT:

				return "Export";

			case EXTERNAL:
				return "External";

			case FALSE:
				return "False";

			case FAR:
				return "Far";

			case FILE:
				return "File";

			case FINALIZATION:
				return "Finalization";

			case FINALLY:
				return "Finally";

			case FOR:
				return "For";

			case FORWARD:
				return "Forward";

			case FUNCTION:
				return "Function";

			case GOTO:
				return "Go To";

			case IF:
				return "If";

			case IMPLEMENTATION:
				return "Implementation";

			case IN:
				return "In";

			case INDEX:
				return "Index";

			case INHERITED:
				return "Inherited";

			case INITIALIZATION:
				return "Initialization";

			case INLINE:
				return "In line";

			case INTERFACE:
				return "Interface";

			case IS:
				return "Is";

			case LABEL:
				return "Label";

			case LIBRARY:
				return "Library";

			case MOD:
				return "Mod";

			case NAME:
				return "Name";

			case NEAR:
				return "Near";

			case NEW:
				return "New";

			case NIL:
				return "Nil";

			case NOT:
				return "Not";

			case OBJECT:
				return "Object";

			case OF:
				return "Of";

			case ON:
				return "On";

			case OPERATOR:
				return "Operator";

			case OR:
				return "Or";

			case OVERRIDE:
				return "Override";

			case PACKED:
				return "Packed";

			case PASCAL:
				return "Pascal";

			case POPSTACK:
				return "PopStack";

			case PRIVATE:
				return "Private";

			case PROCEDURE:
				return "Procedure";

			case PROGRAM:
				return "reserved word \"program\"";

			case PROPERTY:
				return "Property";

			case PROTECTED:
				return "Protected";

			case PUBLIC:
				return "Public";

			case PUBLISHED:
				return "Published";

			case RAISE:
				return "Raise";

			case READ:
				return "Read";

			case RECORD:
				return "Record";

			case REGISTER:
				return "Register";

			case REPEAT:
				return "Repeat";

			case SAVEREGISTERS:
				return "Save Registers";

			case SELF:
				return "Self";

			case SET:
				return "Set";

			case SHL:
				return "SHL";

			case SHR:
				return "SHR";

			case STDCALL:
				return "STD Call";

			case THEN:
				return "Then";

			case TO:
				return "To";

			case TRUE:
				return "True";

			case TRY:
				return "Try";

			case TYPE:
				return "Type";

			case UNIT:
				return "Unit";

			case UNTIL:
				return "Until";

			case USES:
				return "Uses";

			case VAR:
				return "Var";

			case VIRTUAL:
				return "Virtual";

			case WHILE:
				return "While";

			case WITH:
				return "With";

			case XOR:
				return "XOR";
			case SEMICOLON:
				return "Semicolon ';' end of instruction";
			default:
				return null;
			}			
		}
	}

	private TokenType type;
	private String value;

	//Begin of constructors zone

	protected Token(TokenType type) 
	{ 
		this.type = type;
		value =  null;
	}

	protected Token(TokenType type, String value) 
	{ 
		this.type = type;
		this.value = value;
	}

	//End of constructors zone

	//Begin of Getters zone

	public String getValue() 
	{
		return value;
	}

	public TokenType getType() 
	{
		return type;
	}

	//End of Getters zone

	//Begin of Setters zone

	public void setValue(String value) 
	{
		this.value = value;
	}

	//End of Setters zone

	public static Token buildLESS_THAN() 
	{
		return new Token(TokenType.LESS_THAN,"<");
	}
	
	public static Token buildGREATER_THAN() 
	{
		return new Token(TokenType.GREATER_THAN,">");
	}
	
	public static Token buildLESSEQUALS_THAN() 
	{
		return new Token(TokenType.LESSEQUALS_THAN,"<=");
	}
	
	public static Token buildGREATEREQUALS_THAN() 
	{
		return new Token(TokenType.GREATEREQUALS_THAN,">=");
	}
	
	public static Token buildDISTINCT() 
	{
		return new Token(TokenType.DISTINCT,"<>");
	}
	
	public static Token buildTYPE_VARIABLE(String variableIdentifier,Token typeIdentifier) 
	{
		return new TypeVariable(variableIdentifier, typeIdentifier);
	}
	
	public static Token buildCOLON_EQUALS() 
	{
		return new Token(TokenType.COLON_EQUALS,":=");
	}
	
	public static Token buildDIVISION_OPERATOR() 
	{
		return new Token(TokenType.DIVISION_OPERATOR,"/");
	}
	
	public static Token buildARRAY_VARIABLE(String value) 
	{
		return new Token(TokenType.ARRAY_VARIABLE,value);
	}
	
	public static Token buildACTUAL_VARIABLE(String value) 
	{
		return new Token(TokenType.ACTUAL_VARIABLE,value);
	}
	
	public static Token buildPOINTER_VARIABLE(String value) 
	{
		return new Token(TokenType.POINTER_VARIABLE,value);
	}
	
	public static Token buildFILE_VARIABLE(String value) 
	{
		return new Token(TokenType.FILE_VARIABLE,value);
	}
	
	public static Token buildRECORD_VARIABLE(String value) 
	{
		return new Token(TokenType.RECORD_VARIABLE,value);
	}
	
	public static Token buildDOUBLE_DOT() 
	{
		return new Token(TokenType.DOUBLE_DOT,"..");
	}
	
	public static Token buildPOINTER_TYPE() 
	{
		return new Token(TokenType.POINTER_TYPE,"^");
	}
	
	public static Token buildCOLON() 
	{
		return new Token(TokenType.COLON,":");
	}
	
	public static Token buildEQUALS_SIGN() 
	{
		return new Token(TokenType.EQUALS_SIGN,"=");
	}
	
	public static Token buildDOT() 
	{
		return new Token(TokenType.DOT,".");
	}
	
	public static Token buildCOMMA() 
	{
		return new Token(TokenType.COMMA,",");
	}
	
	public static Token buildEOF() 
	{
		return new Token(TokenType.EOF);
	}

	public static Token buildO_PAREN() 
	{
		return new Token(TokenType.O_PAREN,"(");
	}

	public static Token buildC_PAREN() 
	{
		return new Token(TokenType.C_PAREN,")");
	}

	public static Token buildO_CURBRACKET() 
	{
		return new Token(TokenType.O_CURBRACKET,"{");
	}

	public static Token buildC_CURBRACKET() 
	{
		return new Token(TokenType.C_CURBRACKET,"}");
	}

	public static Token buildO_SQBRACKET() 
	{
		return new Token(TokenType.O_SQBRACKET,"[");
	}

	public static Token buildC_SQBRACKET() 
	{
		return new Token(TokenType.C_SQBRACKET,"]");
	}

	public static Token buildString(String textToBuildToken) 
	{
		return new Token(TokenType.STRING,textToBuildToken);
	}

	public static Token buildUNSIGNED_DIGIT_SEQUENCE(String digitSequence) 
	{
		return new Token(TokenType.UNSIGNED_DIGIT_SEQUENCE,digitSequence);
	}

	public static Token buildDIGIT_SEQUENCE(String digitSequence) 
	{
		return new Token(TokenType.DIGIT_SEQUENCE,digitSequence);
	}

	public static Token buildIDENTIFIER(String letterDigitSequence) 
	{
		return new Token(TokenType.IDENTIFIER,letterDigitSequence);
	}

	public static Token buildSIGN() 
	{
		return new Token(TokenType.SIGN);
	}

	public static Token buildCONSTANT_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.CONSTANT_IDENTIFIER,identifier);
	}

	public static Token buildVARIABLE_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.VARIABLE_IDENTIFIER,identifier);
	}

	public static Token buildTYPE_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.TYPE_IDENTIFIER,identifier);
	}

	public static Token buildPROCEDURE_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.PROCEDURE_IDENTIFIER,identifier);
	}

	public static Token buildFUNCTION_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.FUNCTION_IDENTIFIER,identifier);
	}

	public static Token buildBOUND_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.BOUND_IDENTIFIER,identifier);
	}

	public static Token buildFIELD_IDENTIFIER(String identifier) 
	{
		return new Token(TokenType.FIELD_IDENTIFIER,identifier);
	}

	public static Token buildSIGNED_DIGIT_SEQUENCE(String digitSequence) 
	{
		return new Token(TokenType.UNSIGNED_DIGIT_SEQUENCE,digitSequence);
	}

	public static Token buildXOR() 
	{
		return new Token(TokenType.XOR);
	}

	public static Token buildWITH() 
	{
		return new Token(TokenType.WITH);
	}

	public static Token buildWHILE() 
	{
		return new Token(TokenType.WHILE);
	}

	public static Token buildVAR() 
	{
		return new Token(TokenType.VAR);
	}

	public static Token buildUSES() 
	{
		return new Token(TokenType.USES);
	}

	public static Token buildUNTIL() 
	{
		return new Token(TokenType.UNTIL);
	}

	public static Token buildUNIT() 
	{
		return new Token(TokenType.UNIT);
	}

	public static Token buildTYPE() 
	{
		return new Token(TokenType.TYPE);
	}

	public static Token buildTRY() 
	{
		return new Token(TokenType.TRY);
	}

	public static Token buildTRUE() 
	{
		return new Token(TokenType.TRUE);
	}

	public static Token buildTO() 
	{
		return new Token(TokenType.TO);
	}

	public static Token buildTHEN() 
	{
		return new Token(TokenType.THEN);
	}

	public static Token buildSTDCALL() 
	{
		return new Token(TokenType.STDCALL);
	}

	public static Token buildMULTIPLICATION_OPERATOR() 
	{
		return new Token(TokenType.MULTIPLICATION_OPERATOR,"*");
	}

	public static Token buildSHR() 
	{
		return new Token(TokenType.SHR);
	}

	public static Token buildSHL() 
	{
		return new Token(TokenType.SHL);
	}

	public static Token buildSET() 
	{
		return new Token(TokenType.SET);
	}

	public static Token buildSELF() 
	{
		return new Token(TokenType.SELF);
	}

	public static Token buildSAVEREGISTERS() 
	{
		return new Token(TokenType.SAVEREGISTERS);
	}

	public static Token buildREPEAT() 
	{
		return new Token(TokenType.REPEAT);
	}

	public static Token buildREGISTER() 
	{
		return new Token(TokenType.REGISTER);
	}

	public static Token buildRECORD() 
	{
		return new Token(TokenType.RECORD);
	}

	public static Token buildREAD() 
	{
		return new Token(TokenType.READ);
	}

	public static Token buildIF() 
	{
		return new Token(TokenType.IF);
	}

	public static Token buildVIRTUAL() 
	{
		return new Token(TokenType.VIRTUAL);
	}

	public static Token buildRAISE() 
	{
		return new Token(TokenType.RAISE);
	}

	public static Token buildPUBLISHED() 
	{
		return new Token(TokenType.PUBLISHED);
	}

	public static Token buildPUBLIC() 
	{
		return new Token(TokenType.PUBLIC);
	}

	public static Token buildPROTECTED() 
	{
		return new Token(TokenType.PROTECTED);
	}

	public static Token buildPROPERTY() 
	{
		return new Token(TokenType.PROPERTY);
	}

	public static Token buildPROGRAM() 
	{
		return new Token(TokenType.PROGRAM);
	}

	public static Token buildPROCEDURE() 
	{
		return new Token(TokenType.PROCEDURE);
	}

	public static Token buildPRIVATE() 
	{
		return new Token(TokenType.PRIVATE);
	}

	public static Token buildPOPSTACK() 
	{
		return new Token(TokenType.POPSTACK);
	}

	public static Token buildPASCAL() 
	{
		return new Token(TokenType.PASCAL);
	}

	public static Token buildPACKED() 
	{
		return new Token(TokenType.PACKED);
	}

	public static Token buildOVERRIDE() 
	{
		return new Token(TokenType.OVERRIDE);
	}

	public static Token buildOR() 
	{
		return new Token(TokenType.OR);
	}

	public static Token buildON() 
	{
		return new Token(TokenType.ON);
	}

	public static Token buildOF() 
	{
		return new Token(TokenType.OF);
	}

	public static Token buildNOT() 
	{
		return new Token(TokenType.NOT);
	}

	public static Token buildNIL() 
	{
		return new Token(TokenType.NIL);
	}

	public static Token buildIS() 
	{
		return new Token(TokenType.IS);
	}

	public static Token buildFOR() 
	{
		return new Token(TokenType.FOR);
	}

	public static Token buildELSE() 
	{
		return new Token(TokenType.ELSE);
	}

	public static Token buildEND() 
	{
		return new Token(TokenType.END);
	}

	public static Token buildAS() 
	{
		return new Token(TokenType.AS);
	}

	public static Token buildAND() 
	{
		return new Token(TokenType.AND);
	}

	public static Token buildBEGIN() 
	{
		return new Token(TokenType.BEGIN);
	}

	public static Token buildBREAK() 
	{
		return new Token(TokenType.BREAK);
	}

	public static Token buildASM() 
	{
		return new Token(TokenType.ASM);
	}

	public static Token buildASSEMBLER() 
	{
		return new Token(TokenType.ASSEMBLER);
	}

	public static Token buildOBJECT() 
	{
		return new Token(TokenType.OBJECT);
	}

	public static Token buildOPERATOR() 
	{
		return new Token(TokenType.OPERATOR);
	}

	public static Token buildNEW() 
	{
		return new Token(TokenType.NEW);
	}

	public static Token buildNEAR() 
	{
		return new Token(TokenType.NEAR);
	}

	public static Token buildIN() 
	{
		return new Token(TokenType.IN);
	}

	public static Token buildINDEX() 
	{
		return new Token(TokenType.INDEX);
	}

	public static Token buildFUNCTION() 
	{
		return new Token(TokenType.FUNCTION);
	}

	public static Token buildEXIT() 
	{
		return new Token(TokenType.EXIT);
	}

	public static Token buildEXCEPT() 
	{
		return new Token(TokenType.EXCEPT);
	}

	public static Token buildABSTRACT() 
	{
		return new Token(TokenType.ABSTRACT);
	}

	public static Token buildABSOLUTE() 
	{
		return new Token(TokenType.ABSOLUTE);
	}

	public static Token buildINTEGER_NUMBER() 
	{
		return new Token(TokenType.INTEGER_NUMBER);
	}

	public static Token buildSCALE_FACTOR(String scaleFactor) 
	{
		return new Token(TokenType.SCALE_FACTOR,scaleFactor);
	}

	public static Token buildREAL_NUMBER() 
	{
		return new Token(TokenType.REAL_NUMBER);
	}

	public static Token buildNUMBER() 
	{
		return new Token(TokenType.NUMBER);
	}

	public static Token buildIDENTIFIER_LIST() 
	{
		return new Token(TokenType.IDENTIFIER_LIST);
	}

	public static Token buildALIAS() 
	{
		return new Token(TokenType.ALIAS);
	}

	public static Token buildARRAY() 
	{
		return new Token(TokenType.ARRAY);
	}

	public static Token buildCASE() 
	{
		return new Token(TokenType.CASE);
	}

	public static Token buildCDECL() 
	{
		return new Token(TokenType.CDECL);
	}

	public static Token buildCLASS() 
	{
		return new Token(TokenType.CLASS);
	}

	public static Token buildCONST() 
	{
		return new Token(TokenType.CONST);
	}

	public static Token buildCONSTRUCTOR() 
	{
		return new Token(TokenType.CONSTRUCTOR);
	}

	public static Token buildCONTINUE() 
	{
		return new Token(TokenType.CONTINUE);
	}

	public static Token buildDEFAULT() 
	{
		return new Token(TokenType.DEFAULT);
	}

	public static Token buildDESTRUCTOR() 
	{
		return new Token(TokenType.DESTRUCTOR);
	}

	public static Token buildDISPOSE() 
	{
		return new Token(TokenType.DISPOSE);
	}

	public static Token buildDIV() 
	{
		return new Token(TokenType.DIV);
	}

	public static Token buildDO() 
	{
		return new Token(TokenType.DO);
	}

	public static Token buildDOWNTO() 
	{
		return new Token(TokenType.DOWNTO);
	}

	public static Token buildEXPORT() 
	{
		return new Token(TokenType.EXPORT);
	}

	public static Token buildEXPORTS() 
	{
		return new Token(TokenType.EXPORTS);
	}

	public static Token buildEXTERNAL() 
	{
		return new Token(TokenType.EXTERNAL);
	}

	public static Token buildFALSE() 
	{
		return new Token(TokenType.FALSE);
	}

	public static Token buildFAR() 
	{
		return new Token(TokenType.FAR);
	}

	public static Token buildFILE() 
	{
		return new Token(TokenType.FILE);
	}

	public static Token buildFINALIZATION() 
	{
		return new Token(TokenType.FINALIZATION);
	}

	public static Token buildFINALLY() 
	{
		return new Token(TokenType.FINALLY);
	}

	public static Token buildFORWARD() 
	{
		return new Token(TokenType.FORWARD);
	}

	public static Token buildGOTO() 
	{
		return new Token(TokenType.GOTO);
	}

	public static Token buildIMPLEMENTATION() 
	{
		return new Token(TokenType.IMPLEMENTATION);
	}

	public static Token buildINHERITED() 
	{
		return new Token(TokenType.INHERITED);
	}

	public static Token buildINITIALIZATION() 
	{
		return new Token(TokenType.INITIALIZATION);
	}

	public static Token buildINLINE() 
	{
		return new Token(TokenType.INLINE);
	}

	public static Token buildINTERFACE() 
	{
		return new Token(TokenType.INTERFACE);
	}

	public static Token buildLABEL() 
	{
		return new Token(TokenType.LABEL);
	}

	public static Token buildLIBRARY() 
	{
		return new Token(TokenType.LIBRARY);
	}

	public static Token buildMOD() 
	{
		return new Token(TokenType.MOD);
	}

	public static Token buildNAME() 
	{
		return new Token(TokenType.NAME);
	}

	public static Token buildPLUS_SIGN() {
		return new Token(TokenType.PLUS_SIGN,"+");
	}

	public static Token buildMINUS_SIGN() {
		return new Token(TokenType.MINUS_SIGN,"-");
	}
	
	public static Token buildSEMICOLON() {
		return new Token(TokenType.SEMICOLON,";");
	}

	@Override
	public String toString() 
	{
		if(this.value != null) 
		{
			return "Token description:\n\tToken Type: "+this.getType().toString()+"\n\tValue: "+this.getValue();
		}
		else 
		{
			return "Token description:\n\tToken Type: "+this.getType().toString();
		}
	}
}